# First, check the current state of the file at the specified lines
cat -n src/common/m_derived_types.fpp | sed -n '180,210p'

# Search for all uses of %interpolate across the codebase
rg -nP '%interpolate\b' src --type-add 'fpp:*.fpp' --type 'fpp'

# Look for suspicious logical patterns with %interpolate
rg -nP '%interpolate\b.*(\.(true|false)|\.not\.)' src --type-add 'fpp:*.fpp' --type 'fpp'

# Check if there are any conditional patterns that may need review
rg -nP 'if\s*\(.*%interpolate' src --type-add 'fpp:*.fpp' --type 'fpp' -A 2

# Check for assignments to %interpolate in the codebase
rg -nP '%interpolate\s*=' src --type-add 'fpp:*.fpp' --type 'fpp' -B 1 -A 1

#!/bin/bash
# Find allocation and deallocation sites for the new module variables
echo "=== Allocation/Deallocation patterns ==="
rg -nP --type fpp '(allocate|deallocate)\s*\(' src/common/m_model.fpp | head -30

echo -e "\n=== GPU array allocations in entire src/common ==="
rg -nP --type fpp 'gpu_ntrs|gpu_trs_v|gpu_trs_n|gpu_boundary_v|gpu_interpolated_boundary_v|gpu_interpolate|gpu_boundary_edge_count|gpu_total_vertices|stl_bounding_boxes' src/common/ | grep -i allocate | head -20

echo -e "\n=== Where m_model is imported ==="
rg -n 'use.*m_model' src/ | head -20

#!/bin/bash
# Check the finalization routine referenced in the public interface
echo "=== s_model_free subroutine definition ==="
rg -A 50 'subroutine\s+s_model_free' src/common/m_model.fpp | head -60

echo -e "\n=== s_model_write subroutine definition ==="
rg -A 30 'subroutine\s+s_model_write' src/common/m_model.fpp | head -40

#!/bin/bash
# Check if pre_process or post_process reference the new public variables or m_model
echo "=== pre_process usage of m_model ==="
rg -n 'gpu_ntrs|gpu_trs_v|gpu_trs_n|gpu_boundary_v|gpu_interpolated_boundary_v|stl_bounding_boxes|models' src/pre_process/ 2>/dev/null | head -10

echo -e "\n=== post_process usage of m_model ==="
rg -n 'gpu_ntrs|gpu_trs_v|gpu_trs_n|gpu_boundary_v|gpu_interpolated_boundary_v|stl_bounding_boxes|models' src/post_process/ 2>/dev/null | head -10

echo -e "\n=== Check if pre_process or post_process import m_model ==="
rg -n 'use.*m_model' src/pre_process/ src/post_process/ 2>/dev/null

#!/bin/bash
# Get the full m_model.fpp file to understand context
wc -l src/common/m_model.fpp

#!/bin/bash
# Read the module to find allocation patterns
# Focus on where the public arrays are allocated
sed -n '20,100p' src/common/m_model.fpp | cat -n

#!/bin/bash
# Search for allocation patterns - try broader search
rg -n 'allocate' src/common/m_model.fpp | head -30

#!/bin/bash
# Look for initialization subroutines that might allocate these arrays
rg -n 'subroutine.*init\|subroutine.*allocate\|subroutine.*setup' src/common/m_model.fpp | head -20

#!/bin/bash
# Search for where models(:) is allocated
rg -B 3 -A 3 'models\s*\(' src/common/m_model.fpp | head -50

#!/bin/bash
# Look for gpu_ntrs allocation pattern
rg -B 3 -A 3 'gpu_ntrs\s*\(' src/common/m_model.fpp | head -50

#!/bin/bash
# Check how these are used in simulation to understand lifecycle
echo "=== Usage in m_ibm.fpp ==="
rg -B 2 -A 2 'gpu_ntrs\|gpu_trs_v\|gpu_boundary_v\|models\(' src/simulation/m_ibm.fpp | head -40

echo -e "\n=== Usage in pre_process/m_icpp_patches.fpp ==="
rg -B 2 -A 2 'models\(' src/pre_process/m_icpp_patches.fpp | head -40

#!/bin/bash
# Search for allocation of the MODULE-LEVEL arrays in calling modules
echo "=== Search for allocate of gpu_ntrs in entire codebase ==="
rg 'allocate.*gpu_ntrs\|gpu_ntrs.*allocate' src/ | head -20

echo -e "\n=== Search for s_pack_model_for_gpu ==="
rg -n 's_pack_model_for_gpu' src/ | head -20

echo -e "\n=== Look for where gpu arrays are assigned/populated ==="
rg -n 'gpu_ntrs\s*=' src/ | head -20

#!/bin/bash
# Search for deallocate of module-level arrays
echo "=== Deallocate of module-level gpu arrays ==="
rg 'deallocate.*gpu_ntrs\|deallocate.*gpu_trs_v\|deallocate.*models\(' src/ | head -20

echo -e "\n=== Look for finalization in m_ibm.fpp ==="
rg -n 'finalize\|cleanup\|deallocate' src/simulation/m_ibm.fpp | head -20

#!/bin/bash
# Look at s_pack_model_for_gpu implementation
echo "=== s_pack_model_for_gpu subroutine ==="
rg -A 80 'subroutine\s+s_pack_model_for_gpu' src/common/m_model.fpp | head -100

#!/bin/bash
# Final verification: confirm module-level arrays have no lifecycle
echo "=== Complete scan for any allocation pattern ==="
rg 'allocate\s*\(' src/common/m_model.fpp src/simulation/m_ib_patches.fpp src/simulation/m_ibm.fpp | grep -E 'gpu_ntrs|gpu_trs_v|gpu_boundary_v|models\s*\(' || echo "NO ALLOCATIONS FOUND for public module arrays"

echo -e "\n=== Confirm these are truly module-level (public scope) ==="
rg -B 1 'integer.*allocatable.*gpu_ntrs|real.*allocatable.*gpu_trs' src/common/m_model.fpp

#!/bin/bash
# Search for deallocation of these specific arrays
echo "=== Deallocate patterns for public module arrays ==="
rg -n 'deallocate.*gpu_ntrs\|deallocate.*gpu_trs_v\|deallocate.*gpu_boundary_v\|deallocate.*models' src/ | head -20

echo -e "\n=== Broader search for deallocate in m_ib_patches.fpp ==="
rg -n 'deallocate' src/simulation/m_ib_patches.fpp | head -20

echo -e "\n=== Context around gpu array allocations in m_ib_patches.fpp ==="
rg -B 5 -A 10 'allocate.*gpu_ntrs' src/simulation/m_ib_patches.fpp | head -40

#!/bin/bash
# Check what pre_process actually uses from m_model
echo "=== What does pre_process use from m_model? ==="
sed -n '1,50p' src/pre_process/m_icpp_patches.fpp | grep -A 15 'use m_model'

echo -e "\n=== Any direct usage of gpu_* or models arrays in pre_process? ==="
rg -n 'gpu_ntrs|gpu_trs_v|gpu_boundary_v|models\(' src/pre_process/m_icpp_patches.fpp | head -10

rg -nP --type-add 'fpp:*.fpp' --type 'fpp' '\bf_distance_normals_3D_flat\s*\(' src

sed -n '680,700p' src/simulation/m_compute_levelset.fpp

rg -nP 'gpu_ntrs' src/simulation/m_compute_levelset.fpp | head -20

rg -nP '\bgpu_ntrs\b' src --type-add 'fpp:*.fpp' | grep -E '(allocate|dimension|intent|gpu_ntrs\s*=)'

sed -n '1110,1160p' src/simulation/m_ib_patches.fpp

sed -n '650,710p' src/simulation/m_compute_levelset.fpp

#!/bin/bash
# Find all call sites to s_pack_model_for_gpu
rg -nP --type-add 'fpp:*.fpp' --type 'fpp' '\bs_pack_model_for_gpu\s*\(' src || true

#!/bin/bash
# Also search for the subroutine definition and nearby code
rg -nP --type-add 'fpp:*.fpp' --type 'fpp' -B 5 -A 20 'subroutine s_pack_model_for_gpu' src || true

#!/bin/bash
# Check if ma%trs_v or ma%trs_n are referenced elsewhere to understand lifecycle
rg -nP --type-add 'fpp:*.fpp' --type 'fpp' 'ma%trs_v|ma%trs_n' src || true

#!/bin/bash
# Get context around the call site in m_ib_patches.fpp
sed -n '1080,1120p' src/simulation/m_ib_patches.fpp

#!/bin/bash
# Search for surrounding loop context (broader range)
sed -n '1050,1130p' src/simulation/m_ib_patches.fpp

#!/bin/bash
# Check if models is deallocated/re-initialized somewhere
rg -nP --type-add 'fpp:*.fpp' --type 'fpp' 'models\s*\(|deallocate.*models' src/simulation/ | head -30

#!/bin/bash
# Check if s_instantiate_STL_models or models are re-initialized in any time-stepping/simulation loop
rg -nP --type-add 'fpp:*.fpp' --type 'fpp' 's_instantiate_STL_models|allocate.*models\(' src/simulation/ | grep -v '\.fpp-' | head -20

#!/bin/bash
# Search for any re-initialization or deallocate of models during simulation
rg -nP --type-add 'fpp:*.fpp' --type 'fpp' 'deallocate.*models|models.*=|trs_v.*deallocate|trs_n.*deallocate' src | head -20

#!/bin/bash
# 1. Find s_instantiate_STL_models and s_apply_ib_patches calls to check ordering
echo "=== Looking for s_instantiate_STL_models and s_apply_ib_patches calls ==="
rg -n 's_instantiate_STL_models|s_apply_ib_patches' src/simulation/ --type fpp

echo -e "\n=== Checking if they're in correct order within m_ibm.fpp ==="
rg -n 's_instantiate_STL_models\|s_apply_ib_patches' src/simulation/m_ibm.fpp -B 2 -A 2

#!/bin/bash
# 2. Find where gpu_ntrs/gpu_trs_v/gpu_trs_n are allocated and managed
echo "=== Finding gpu_ntrs/gpu_trs_v/gpu_trs_n allocations and GPU_ENTER_DATA ==="
rg -n 'allocate.*gpu_ntrs|allocate.*gpu_trs_v|allocate.*gpu_trs_n' src/simulation/ --type fpp

echo -e "\n=== Searching for GPU_ENTER_DATA calls with these variables ==="
rg -n 'GPU_ENTER_DATA' src/simulation/m_ib_patches.fpp -A 5 || rg -n 'GPU_ENTER_DATA' src/simulation/m_ibm.fpp -A 5

#!/bin/bash
# 3. Verify bounding-box logic in both functions
echo "=== Checking s_ib_model for bounding-box logic ==="
sed -n '828,875p' src/simulation/m_ib_patches.fpp | grep -n 'il\|ir\|jl\|jr\|bounding' || echo "No bounding-box narrowing found in s_ib_model"

echo -e "\n=== Checking s_ib_3d_model for bounding-box logic ==="
sed -n '877,953p' src/simulation/m_ib_patches.fpp | grep -n 'il\|ir\|jl\|jr\|kl\|kr\|bounding'

#!/bin/bash
# 4. Check data movement for gpu_ntrs/gpu_trs_v/gpu_trs_n in the GPU loop context
echo "=== Checking GPU_PARALLEL_LOOP copyin clause for these variables ==="
sed -n '828,875p' src/simulation/m_ib_patches.fpp | grep -A 2 'GPU_PARALLEL_LOOP'

echo -e "\n=== In s_ib_3d_model ==="
sed -n '877,953p' src/simulation/m_ib_patches.fpp | grep -A 2 'GPU_PARALLEL_LOOP'

echo -e "\n=== Checking if gpu_trs_v/gpu_trs_n are explicitly referenced ==="
rg -n 'gpu_trs_v|gpu_trs_n' src/simulation/m_ib_patches.fpp | head -20

#!/bin/bash
# Check the broader context of s_apply_ib_patches and see if GPU_ENTER_DATA creates persistent region
rg -n 's_apply_ib_patches' src/simulation/m_ibm.fpp -B 10 -A 20 | head -80

#!/bin/bash
# Look for GPU_DATA wrapping context around the kernel calls
rg -n 'GPU_DATA|GPU_ENTER_DATA|GPU_EXIT_DATA' src/simulation/m_ibm.fpp -B 2 -A 2

#!/bin/bash
# Check f_model_is_inside_flat signature to see if it expects device arrays
rg -n 'subroutine\s+f_model_is_inside_flat|function\s+f_model_is_inside_flat' src/simulation/ -A 15

#!/bin/bash
# Verify where GPU_ENTER_DATA is called and what scope it governs
rg -n 'subroutine s_instantiate_STL_models' src/simulation/m_ib_patches.fpp -A 300 | tail -150

#!/bin/bash
# Check if there's a persistent GPU_ENTER_DATA region wrapping both calls
# Look for GPU_ENTER_DATA without matching GPU_EXIT_DATA
rg -n 'GPU_ENTER_DATA|GPU_EXIT_DATA' src/simulation/m_ibm.fpp | head -40

#!/bin/bash
# Verify the exact scope of GPU_ENTER_DATA at line 1160 - is it persistent?
sed -n '1140,1170p' src/simulation/m_ib_patches.fpp

#!/bin/bash
# Check where gpu_ntrs/gpu_trs_v/gpu_trs_n might be declared with present() or accessed post-ENTER_DATA
rg -n 'present\|gpu_ntrs\|gpu_trs_v\|gpu_trs_n' src/simulation/m_ib_patches.fpp | grep -A 3 -B 3 'present'

#!/bin/bash
# Search for how GPU data persistence is managed - look for surrounding GPU_DATA or block context
sed -n '1100,1170p' src/simulation/m_ib_patches.fpp | head -80

#!/bin/bash
# Check if there's a GPU_EXIT_DATA anywhere in the file
rg -n 'GPU_EXIT_DATA' src/simulation/m_ib_patches.fpp || echo "No GPU_EXIT_DATA found"

# Check broader context around GPU_ENTER_DATA call at line 1160
sed -n '1090,1170p' src/simulation/m_ib_patches.fpp

#!/bin/bash
# Look for how f_model_is_inside_flat uses the arrays - check if it's marked GPU_ROUTINE
rg -n 'f_model_is_inside_flat' src/simulation/ -A 5 | head -40

#!/bin/bash
# Check the GPU macro definitions to understand data region semantics
fd 'gpuParallelization\|gpu.*\.fpp' src/simulation/ && cat src/simulation/gpuParallelization.fpp 2>/dev/null | head -200 || echo "File not found, searching for macro definitions"
rg -n '@:GPU_PARALLEL_LOOP|@:GPU_DATA|@:GPU_ENTER_DATA' src/ -B 2 | head -50

#!/bin/bash
# Check if there's a broad GPU_DATA or GPU context managing device persistence around the entire flow
rg -n 'GPU_DATA|GPU_ENTER_DATA|GPU_EXIT_DATA|GPU_ROUTINE' src/simulation/m_ibm.fpp | head -20

#!/bin/bash
# Look at the main timestepping loop structure to understand device data persistence scope
rg -n 'subroutine s_time_step\|end subroutine s_time_step' src/simulation/m_ibm.fpp -A 300 | head -150

#!/bin/bash
# Check if the GPU arrays like gpu_trs_v are declared as module-level allocatables that persist
rg -n 'gpu_ntrs|gpu_trs_v|gpu_trs_n' src/simulation/m_ib_patches.fpp | grep -i 'allocatable\|dimension' | head -10

#!/bin/bash
# Search for module-level declarations of gpu arrays
rg -n 'allocatable.*gpu_ntrs|allocatable.*gpu_trs_v|allocatable.*gpu_trs_n' src/simulation/m_ib_patches.fpp -B 2 -A 2

#!/bin/bash
# Find where these gpu arrays are declared at module scope
rg -n 'integer.*allocatable|real.*allocatable' src/simulation/m_ib_patches.fpp | grep -i gpu

#!/bin/bash
# Get the entire module-level variable declarations section
sed -n '1,100p' src/simulation/m_ib_patches.fpp | grep -n 'allocatable\|dimension'

#!/bin/bash
# Search for the module declaration section more broadly
head -200 src/simulation/m_ib_patches.fpp | tail -100

#!/bin/bash
# Check module-level variable declarations in m_ib_patches
grep -n 'module m_ib_patches' src/simulation/m_ib_patches.fpp -A 50 | head -60

#!/bin/bash
# Verify whether gpu_trs_v/gpu_trs_n require present() or explicit data movement in nested GPU regions
# Look for documentation or examples in gpuParallelization guidance
rg -n 'present\|GPU_PARALLEL_LOOP' src/simulation/m_ibm.fpp -B 2 -A 3 | head -80

#!/bin/bash
# Check if any other GPU_PARALLEL_LOOP kernels use variables allocated via GPU_ENTER_DATA elsewhere
rg -n 'GPU_PARALLEL_LOOP' src/simulation/ -A 5 | grep -A 5 'copyin\|present' | head -60

#!/bin/bash
# Critical check: verify gpu_ntrs/gpu_trs_v/gpu_trs_n are referenced but NOT in data clauses
echo "=== In s_ib_model GPU_PARALLEL_LOOP (line ~850) ==="
sed -n '850,870p' src/simulation/m_ib_patches.fpp

echo -e "\n=== In s_ib_3d_model GPU_PARALLEL_LOOP (line ~920) ==="
sed -n '920,940p' src/simulation/m_ib_patches.fpp

echo -e "\n=== Checking for 'present' in GPU_PARALLEL_LOOP patterns ==="
rg -n 'present=' src/simulation/ | head -10

#!/bin/bash
# Check if gpu_ntrs/gpu_trs_v/gpu_trs_n are module-level in m_model or elsewhere
fd -e fpp -e f90 | xargs grep -l 'gpu_ntrs\|gpu_trs_v' | head -5
rg -n 'integer.*allocatable.*gpu_ntrs|real.*allocatable.*gpu_trs' src/ -B 2 | head -30

#!/bin/bash
# Check if s_instantiate_STL_models is called before s_apply_ib_patches in BOTH initial and restart paths
echo "=== Initial setup (lines ~100-120) ==="
sed -n '100,120p' src/simulation/m_ibm.fpp

echo -e "\n=== Restart/update path (lines ~935-950) ==="
sed -n '935,950p' src/simulation/m_ibm.fpp

#!/bin/bash
# Verify that GPU arrays are module-level and persisted
echo "=== Module scope declaration in m_model.fpp ==="
sed -n '30,40p' src/common/m_model.fpp

echo -e "\n=== Confirm they're never deallocated ==="
rg -n 'deallocate.*gpu_ntrs|deallocate.*gpu_trs_v|deallocate.*gpu_trs_n' src/

#!/bin/bash
# Search for all occurrences of stl_bounding_boxes in the codebase
echo "=== stl_bounding_boxes allocations and usage ==="
rg -n "stl_bounding_boxes" src/simulation/m_ib_patches.fpp src/common/m_model.fpp 2>/dev/null || echo "Not found in specified files"

# Broader search
rg -n "stl_bounding_boxes" --type f90 --type fpp 2>/dev/null || true

#!/bin/bash
# Check total_vertices initialization and usage pattern
echo "=== total_vertices usage pattern ==="
rg -n "total_vertices" src/simulation/m_ib_patches.fpp | head -50

# Check gpu_total_vertices
echo "=== gpu_total_vertices pattern ==="
rg -n "gpu_total_vertices" src/simulation/m_ib_patches.fpp

#!/bin/bash
# Check gpu_* allocations and deallocations
echo "=== gpu_* array allocations ==="
rg -n "allocate.*gpu_" src/simulation/m_ib_patches.fpp | head -30

echo "=== gpu_* deallocations ==="
rg -n "deallocate.*gpu_" src/simulation/m_ib_patches.fpp | head -30

# Check if there's a finalize/cleanup subroutine
echo "=== Potential cleanup routines ==="
rg -n "subroutine.*finalize|subroutine.*cleanup" src/simulation/m_ib_patches.fpp

#!/bin/bash
# Check the module-level declarations to understand data structure
echo "=== Module-level declarations for gpu_* and stl_bounding_boxes ==="
rg -n "real.*gpu_|integer.*gpu_|allocatable.*gpu_|real.*stl_bounding|allocatable.*stl_bounding" src/simulation/m_ib_patches.fpp | head -40

# Look for module/global scope context
head -150 src/simulation/m_ib_patches.fpp | tail -100